test(types): re-derive and pin the WIDER ledger's #7760 pairs figure, amend #8222's stale live-figure guidance - #8575

Fixes #8458
Fixes #8248

Two cards, one file, one branch — both are a claim in zod-mirror-parity.test.ts's own
prose that no instrument covers.

⭐ The durable finding: 16 was never right — it was never defined

The card, its triage and the dispatch all framed this as a figure that went stale when
PR #8354 moved the ledger. It did not go stale. 16 is neither reading of the word:
the move emptied 13 entries and touched 18, and no definition of "pairs" yields 16 at
either revision. Re-deriving it is what showed this — adopting the reviewer's 18 would have
produced the same corrected digit and left the actual defect in place.

So the class is not "a number rotted beside pinned neighbours". It is a number was
published with no definition, and this file's own reviewers reproduced it twice without
one — the card's author, and the contract reviewer who measured 18 and reported it as a
correction rather than as an ambiguity. That is why step 3 of the card existed, and it is
why this PR writes a definition and a decomposition into the sentence instead of
correcting a digit: a corrected 18 with no definition forks again the first time someone
counts the emptied entries instead.

Card #8458 — the pairs figure

The count, and how it was derived

18. The sentence now reads 19 keys across **18** pairs LEFT (**13 emptied + 5 reduced = 18**).

⛔ Not adopted from the card or from triage — both said in as many words not to, and
neither had re-derived it. Method, in full:

1. The transition the sentence describes is PR fix(types): give seven recursion-breaking zod mirrors their declaration as both type arguments #8354's, and the two trees either side of
   it are 645ecb98c (its parent) and a480f797a (its merge). Confirmed by reading the
   ledger's own pinned totals out of the file at each: **34 entries** … **52 keys** … **61 arms** before, **23 entries** … **36 keys** … **47 arms** after — exactly the
   two states the sentence names.
2. The reader is this file's own ledgerEntryMembers('WiderThanDeclared'), not a
   re-implementation: the derivation script slices that function's source text out of the
   working-tree copy of the test file, transpiles it with ts.transpileModule, and calls
   it against each revision. So the instrument that sizes the ledger in CI is byte-identical
   to the one that sized it here. ⛔ Nothing was hand-reconciled.
3. Diff the entry-to-key pairs:

BEFORE (645ecb98c): { entries: 34, keys: 52 }
AFTER  (a480f797a): { entries: 23, keys: 36 }
KEYS LEFT   : 19
KEYS ENTERED:  3
PAIRS that lost at least one key : 18
  of which EMPTIED (entry gone)  : 13
  of which REDUCED (entry stays) :  5
NEW entries in AFTER             :  2
CHECK entries: 34 - 13 emptied + 2 new = 23 (after=23)
CHECK keys   : 52 - 19 left  + 3 entered = 36 (after=36)

Both movements close against figures already pinned at those revisions, so the reading is
anchored on both sides rather than asserted. The 5 reduced entries are
AppComponentSchema, DashboardComponentSchema, PageNodeSchema, ObjectViewSchema,
DetailViewSchema.

⭐ 16 is wrong under both readings of the word — 13 emptied, 18 touched. That is the
strongest argument for step 3 below: it was not a stale figure, it was an undefined one.

PR #8354's body needs no correction — it merged 2026-09-08, so the card's conditional
("if it has not merged") does not fire. Nothing was edited there.

(a) or (b): (a), pinned

headerFigures(/(\d+) of the registered pairs carry TYPE drift TODAY/) already pins a
pairs-shaped figure in this file, so this copies a precedent rather than opening one, and
the card's cost argument ("every pinned figure is a maintenance cost") is weaker than the
card assumed. The maintenance cost is also near zero because the figure is historical:
it is a reading of two fixed trees and cannot rot, so no future ledger move touches it.
Dropping it under (b) would have deleted the only statement of how big that move was — the
neighbouring It read 34 / 52 / 61 … sentences give the totals but not the shape of the
movement.

The pin is a new describe at the bottom of the file, deliberately not folded into the
objectui#8252 block: that one derives LIVE figures from the arms, and

⛔ nothing here compares the movement to the live ledger. WiderThanDeclared today is
neither of the two trees (objectui#8338 moved it again afterwards), and pointing a figure
at it would make the statement live, rot it on the next ledger move, and reintroduce the
hand re-derivation objectui#8243 removed. What is checked is the statement's internal
arithmetic — emptied + reduced == pairs, the restated total, and pairs <= keysLeft
(a touched pair contributed at least one of the keys that left) — plus non-vacuity legs so
an all-zero rewrite cannot satisfy it.

The definition of "pairs"

Written where the figure stands, because a number without one forks again:

pairs there counts every entry the move TOUCHED — an entry that lost a key and KEPT
others is still one it moved — and emptied is the subset that lost its whole content.

Both readings are now written down, which is why the decomposition (13 emptied + 5 reduced)
is in the sentence instead of a bare digit: the reader can see which quantity is which.

Card #8248 — the stale live in objectui#8222's exclusion note

Implemented as ruled (decision batch #71, 2026-09-07), not re-opened.

• The rule is written once, in the file header: the LIVE/HISTORICAL split governs
  assertion messages too, judged per CLAUSE — a clause that RECORDS A MEASUREMENT is
  historical and ⛔ never rewritten by a later card; a clause that GIVES GUIDANCE is live,
  must be true now, and a later card may and must amend it, citing the card that moved it.

• The guidance half is amended. ⚠️ ONE live figure in the header is deliberately NOT here loses the word live, and an ⚠️ AMENDED (objectui#8248 …) paragraph states that
  the seed decomposition is a HISTORICAL reading anchored at named revisions per
  objectui#8243, that it therefore carries none of a live figure's obligations, and that the
  action the word "live" sends a reader off to do — pin it, or exclude it afresh — is the
  wrong one.

• The two record clauses are untouched, byte-identical, and named here explicitly:

  1. It needs each key's PROVENANCE and no ledger in this file records that, so nothing here can derive it.
  2. It is excluded in writing where it stands, which is the other half of objectui#8222 — every live figure in that header is pinned or excluded with its reason, and ⛔ a new one that is neither should not be added.

  ⛔ No digits were copied into the note: restating the decomposition there would have
  created the second unpinned copy the record clause exists to forbid.

Two companion edits inside the same sentence's radius

Both are the same claim as #8248's subject sentence, on the claimed file surface, and
leaving them would have produced exactly the "a stale copy survives beside a corrected one"
shape this file records. Neither is a new finding; flagging them for the reviewer:

• The file header itself said Exactly one live figure is excluded rather than pinned
  about the same seed decomposition. Amended the same way (the word, plus one clause citing
  objectui#8243 / objectui#8248). Leaving it would have contradicted the rule three lines below it.
• objectui#8243's own block comment said That note is left exactly as it stands, which
  objectui#8248 has now made false. Changed to the past tense with one clause recording the
  amendment. Its record clause — it is an assertion message objectui#8243 has no business editing — is untouched.

Gates

Lint is a declared narrowing, measured, not skipped. eslint on the changed file: 1 file,
0 errors, 0 warnings (--format json, count read from the JSON). Population read from
eslint's own config via ESLint#isPathIgnored over git ls-files: 4518 of 4520 tracked
lintable-extension files are in scope for eslint .. Invariance: eslint.config.js sets no
parserOptions.project and no projectService, so type-aware linting is off and a one-file
diff cannot move the verdict on any untouched file. The full farm is CI's run.
All figures above are from the final commit, 234eeea92.

Reverse verification

Predicted direction: turns red. Run from the committed tree, restore proven by blob hash
and an empty git diff HEAD, with an EXIT INT TERM trap holding absolute paths.

• Control (unmutated): green, and the new test is named in the verbose output —
  ✓ … the objectui#7760 movement figures reconcile with themselves (objectui#8458) > the pairs that move touched equal its emptied entries plus its reduced ones
• M1 — the digit put back to 16 (the actual defect): on-disk proof removed-text count=0, injected-text count=1, blob b71bcb40… != HEAD 16c95033… →
  Tests 1 failed | 31 passed, expected { decomposition: 18, …(2) } to deeply equal { decomposition: 16, …(2) }.
• M2 — the decomposition reworded away: → the header spelling /\*\*(\d+) emptied \+ (\d+) reduced = (\d+)\*\*/ must occur exactly once … it occurs 0 times. A reword that drops the figure is red, not silently unpinned.
• Restore after each leg and at trap: leg restored (blob == HEAD) /
  TRAP-RESTORE OK: blob matches HEAD and git diff HEAD is empty. Re-run in full against the
  final commit, so every hash above is that tree's.

One self-audit, worth the reviewer's eye

The first draft of the new prose restated the two pinned figures a second time, in the
sentence explaining the fork — a restatement no pin reaches, which is the objectui#7733
shape one line further in and precisely what this paragraph warns against. It was removed
before the branch was opened for review: the sentence now says 16 "is NEITHER of the two
readings above" and states in writing that they are ⛔ not restated as digits. The digits
appear exactly once each, inside the pinned spellings.

Merged origin/main — what was re-derived, and what is immune and why

origin/main at 57bad9b00 was merged in (a merge, ⛔ not a rebase); the branch was
behind independently of any sequencing. No conflict, and the reason is measurable rather
than asserted: git log f5cfbbd81..origin/main -- packages/types/src/__tests__/zod-mirror-parity.test.ts
is empty — nothing on main has touched this file since the branch's base. The file's
blob hash is 16c95033 on both sides of the merge.

Re-derived, not carried over. The two revision extracts were deleted and re-cut from
git, and the whole derivation re-executed on the merged tree:

• The pairs movement is unchanged, byte-identical output: BEFORE (645ecb98c) {entries: 34, keys: 52},
  AFTER (a480f797a) {entries: 23, keys: 36}, 19 keys left, 3 entered, 18 pairs touched,
  13 emptied, 5 reduced, both arithmetic checks closing. The sliced instrument hashed
  identically (4355dcac9ccd), so the reader did not move either.
• Why it is immune — argued, then confirmed. Every figure in that sentence is a reading
  of two fixed trees. 645ecb98c and a480f797a are immutable, so nothing landing on
  main afterwards can change what the ledger held there. That is exactly the objectui#8243
  property this PR leans on; re-running it is the confirmation, not the argument.
• The file's live figures are the ones that could have moved, and they are not re-derived
  by hand here: the existing objectui#7733 / objectui#8222 / objectui#8252 pins compare them
  to the ledgers on every run, so the post-merge Tests 32 passed (32) is that comparison
  coming back green. Had main moved a ledger, those blocks would be red, not silent.
• ⚠️ No figure moved, so there is no finding to report here. Had one moved, it would have
  been filed as a card, not absorbed into this PR.

Post-merge re-runs at 6d7d72a08: parity test Tests 32 passed (32); pnpm --filter @object-ui/types type-check → VERDICT command-exit 0; check-control-bytes OK (6777
tracked text files); check-changeset-presence exit 0; check-governed-queue-guard --test
→ NOT GOVERNED; eslint on the changed file 1 file / 0 errors / 0 warnings, against a
population of 4520 of 4522 tracked lintable files read from eslint's own config, still
with no parserOptions.project and no projectService. The reverse verification was re-run
in full against the merged HEAD; every hash in the section above is from that run.

Clause-② carrier check

node scripts/pm/check-clause2-carriers.mjs --pair 8575, run from /home/user/objectstack
as instructed, exits 2, and its own line says why: it reads objectstack-ai/objectstack
by default, where #8575 is a different pull request, so "the pair could not be formed, so
nothing about it was judged" — ⛔ not a clearance, and ⛔ not a failure either. Pointed at
this repo, PM_SWEEP_REPO=objectstack-ai/objectui … --pair 8575 exits 0: both #8458 and
#8248 read as "the clause-② declaration is readable in the fixed spelling and both carriers
agree, and its diff carries no widening tell."

Release notes

.changeset/8458-parity-header-pairs-figure.md, empty frontmatter. The file is under
src/ so the presence gate counts it, but nothing published moves: the package build
tsconfig.json excludes **/__tests__/** and @object-ui/types' files is ["dist", …].

🤖 Generated with Claude Code

https://claude.ai/code/session_01CZY49skxUBYyJcdnTcYPrE

Generated by Claude Code